import numpy as np
import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt
from scipy.spatial.distance import cdist
from sklearn import cluster
from yellowbrick.cluster import KElbowVisualizer
from sklearn.preprocessing import normalize
from sklearn.metrics.cluster import adjusted_rand_score
from sklearn.metrics import silhouette_score
from sklearn.cluster import MeanShift, estimate_bandwidth, KMeans
from sklearn.cluster import AgglomerativeClustering
from sklearn.metrics import v_measure_score
from sklearn.preprocessing import normalize
import scipy.cluster.hierarchy as shc
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
from keras.preprocessing.sequence import TimeseriesGenerator
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras import layers
from keras.layers import BatchNormalization
from keras import models
from keras import optimizers
from keras import callbacks
from keras.layers import Dropout
from sklearn import metrics
from sklearn.metrics import classification_report
import math
from sklearn.metrics import mean_squared_error
%matplotlib inline
from google.colab import drive
drive.mount('/content/drive')
import tensorflow as tf
print(tf.__version__)
df = pd.read_csv('/content/drive/My Drive/Final thesis/reshapedGC.csv', parse_dates = ['Datetime'], dayfirst = True,na_filter=False)
df.head()
def getSeason(month):
if (month == 6 or month == 7 or month == 8):
return "WINTER"
elif(month == 9 or month == 10 or month == 11):
return "SPRING"
elif(month == 12 or month == 1 or month == 2):
return "SUMMER"
else:
return "AUTUMN"
df['month'] = df['Datetime'].apply(lambda x: x.month)
df['hour'] = df['Datetime'].apply(lambda x: x.hour)
df['minute'] = df['Datetime'].apply(lambda x: x.minute)
df['season'] = df['month'].apply(lambda x: getSeason(x))
df.season.unique()
df.season.value_counts()
dfS = df.groupby(['hour','season']).mean()
dfS.head()
#dfGCwk = dfGC[dfGC.weekday == True]
df_A = df[df.season == 'AUTUMN']
df_W = df[df.season == 'WINTER']
df_SU = df[df.season == 'SUMMER']
df_SP = df[df.season == 'SPRING']
df_A = df_A.drop(columns = ['season','month', 'hour', 'minute'])
df_W = df_W.drop(columns = ['season','month', 'hour', 'minute'])
df_SU = df_SU.drop(columns = ['season','month', 'hour', 'minute'])
df_SP = df_SP.drop(columns = ['season','month', 'hour', 'minute'])
df_A = df_A.groupby(['Datetime']).mean()
df_W = df_W.groupby(['Datetime']).mean()
df_SU = df_SU.groupby(['Datetime']).mean()
df_SP = df_SP.groupby(['Datetime']).mean()
df_A.head()
X_A = df_A.transpose()
X_W = df_W.transpose()
X_SU = df_SU.transpose()
X_SP = df_SP.transpose()
print(X_A.shape, X_W.shape, X_SU.shape, X_SP.shape)
def elbow_method(dataframe, min_k, max_k):
# Try all k's between min_k and max_k
cluster_nums = range(min_k, max_k + 1)
# Array of K-means algorithm objects
k_mean_algs = [cluster.KMeans(n_clusters = k) for k in cluster_nums]
# Array with the results of the K-mean algorithms
k_mean_res = [alg.fit(dataframe) for alg in k_mean_algs]
# Array with the centroids for each value of k
centroids = [res.cluster_centers_ for res in k_mean_res]
# Euclidean distance between the points of the cluster and the centroids
distances = [cdist(dataframe, centroid, 'euclidean') for centroid in centroids]
# Get the closest centroid (and the corresponding distance)
min_indices = [np.argmin(distance, axis = 1) for distance in distances]
min_distances = [np.min(distance, axis = 1) for distance in distances]
# Calculate the average squared distance
avg_sum_squares = [sum(dist ** 2) / df_A.shape[0] for dist in min_distances]
# Plot the elbow graph
fig = plt.figure(figsize=(9,5))
ax = fig.add_subplot(111)
ax.plot(cluster_nums, avg_sum_squares, 'b*-',color='tab:green')
plt.grid(True)
plt.xlabel('Number of clusters')
plt.ylabel('Average sum of squares within cluster')
plt.show()
return (k_mean_algs, k_mean_res)
k_algs, k_res = elbow_method(X_A,2,10)
k_algs, k_res = elbow_method(X_W,2,10)
k_algs, k_res = elbow_method(X_SU,2,10)
k_algs, k_res = elbow_method(X_SP,2,10)
#km_ = KMeans().fit(X_A)
#pd.Series.value_counts(km_.labels_)
#visualizer = KElbowVisualizer(km_, k=(2,10), timings=False)
#visualizer.fit(X_A)
#visualizer.show()
#km_ = KMeans().fit(X_W)
#pd.Series.value_counts(km_.labels_)
#visualizer = KElbowVisualizer(km_, k=(2,10), timings=False)
#visualizer.fit(X_A)
#visualizer.show()
#km_ = KMeans().fit(X_SU)
#pd.Series.value_counts(km_.labels_)
#
#visualizer = KElbowVisualizer(km_, k=(2,10), timings=False)
#visualizer.fit(X_A)
#visualizer.show()
#km_ = KMeans().fit(X_SP)
#pd.Series.value_counts(km_.labels_)##
#visualizer = KElbowVisualizer(km_, k=(2,10), timings=False)
#visualizer.fit(X_A)
#visualizer.show()
v_scores = []
N_Clusters = [2, 3, 4, 5, 6, 7, 8]
km_2_A = KMeans(2).fit(X_A)
km_2_Av = KMeans(2).fit(df_A)
True_lables1 =km_2_Av.labels_
labels1 = km_2_Av.predict(df_A)
v_scores.append(v_measure_score(df_A['4'], labels1))
km_3_A = KMeans(3).fit(X_A)
km_3_Av = KMeans(3).fit(df_A)
True_lables2 =km_3_Av.labels_
labels2 = km_3_Av.predict(df_A)
v_scores.append(v_measure_score(df_A['4'], labels2))
km_4_A = KMeans(4).fit(X_A)
km_4_Av = KMeans(4).fit(df_A)
True_lables3 =km_4_Av.labels_
labels3 = km_4_Av.predict(df_A)
v_scores.append(v_measure_score(df_A['4'], labels3))
km_5_A = KMeans(5).fit(X_A)
km_5_Av = KMeans(5).fit(df_A)
True_lables4 =km_5_Av.labels_
labels4 = km_5_Av.predict(df_A)
v_scores.append(v_measure_score(df_A['4'], labels4))
km_6_A = KMeans(6).fit(X_A)
km_6_Av = KMeans(6).fit(df_A)
True_lables5 =km_6_Av.labels_
labels5 = km_6_Av.predict(df_A)
v_scores.append(v_measure_score(df_A['4'], labels5))
km_7_A = KMeans(7).fit(X_A)
km_7_Av = KMeans(7).fit(df_A)
True_lables6 =km_7_Av.labels_
labels6 = km_7_Av.predict(df_A)
v_scores.append(v_measure_score(df_A['4'], labels6))
km_8_A = KMeans(8).fit(X_A)
km_8_Av = KMeans(8).fit(df_A)
True_lables7 =km_8_Av.labels_
labels7 = km_8_Av.predict(df_A)
v_scores.append(v_measure_score(df_A['4'], labels7))
v_scores_w = []
N_Clusters = [2, 3, 4, 5, 6, 7, 8]
km_2_W = KMeans(2).fit(X_W)
km_2_Wv = KMeans(2).fit(df_W)
True_lables1_w =km_2_Wv.labels_
labels1_w = km_2_Wv.predict(df_W)
v_scores_w.append(v_measure_score(df_W['4'], labels1_w))
km_3_W = KMeans(3).fit(X_W)
km_3_Wv = KMeans(3).fit(df_W)
True_lables2_w =km_3_Wv.labels_
labels2_w = km_3_Wv.predict(df_W)
v_scores_w.append(v_measure_score(df_W['4'], labels2_w))
km_4_W = KMeans(4).fit(X_W)
km_4_Wv = KMeans(4).fit(df_W)
True_lables3_w =km_4_Wv.labels_
labels3_w = km_4_Wv.predict(df_W)
v_scores_w.append(v_measure_score(df_W['4'], labels3_w))
km_5_W = KMeans(5).fit(X_W)
km_5_Wv = KMeans(5).fit(df_W)
True_lables4_w =km_5_Wv.labels_
labels4_w = km_5_Wv.predict(df_W)
v_scores_w.append(v_measure_score(df_W['4'], labels4_w))
km_6_W = KMeans(6).fit(X_W)
km_6_Wv = KMeans(6).fit(df_W)
True_lables5_w =km_6_Wv.labels_
labels5_w = km_6_Wv.predict(df_W)
v_scores_w.append(v_measure_score(df_W['4'], labels5_w))
km_7_W = KMeans(7).fit(X_W)
km_7_Wv = KMeans(7).fit(df_W)
True_lables6_w =km_7_Wv.labels_
labels6_w = km_7_Wv.predict(df_W)
v_scores_w.append(v_measure_score(df_W['4'], labels6_w))
km_8_W = KMeans(8).fit(X_W)
km_8_Wv = KMeans(8).fit(df_W)
True_lables7_w =km_8_Wv.labels_
labels7_w = km_8_Wv.predict(df_W)
v_scores_w.append(v_measure_score(df_W['4'], labels7_w))
v_scores_su = []
N_Clusters = [2, 3, 4, 5, 6, 7, 8]
km_2_SU = KMeans(2).fit(X_SU)
km_2_SUv = KMeans(2).fit(df_SU)
True_lables1_su =km_2_SUv.labels_
labels1_su = km_2_SUv.predict(df_SU)
v_scores_su.append(v_measure_score(df_SU['4'], labels1_su))
km_3_SU = KMeans(3).fit(X_SU)
km_3_SUv = KMeans(3).fit(df_SU)
True_lables2_su =km_3_SUv.labels_
labels2_su = km_3_SUv.predict(df_SU)
v_scores_su.append(v_measure_score(df_SU['4'], labels2_su))
km_4_SU = KMeans(4).fit(X_SU)
km_4_SUv = KMeans(4).fit(df_SU)
True_lables3_su =km_4_SUv.labels_
labels3_su = km_4_SUv.predict(df_SU)
v_scores_su.append(v_measure_score(df_SU['4'], labels3_su))
km_5_SU = KMeans(5).fit(X_SU)
km_5_SUv = KMeans(5).fit(df_SU)
True_lables4_su =km_5_SUv.labels_
labels4_su = km_5_SUv.predict(df_SU)
v_scores_su.append(v_measure_score(df_SU['4'], labels4_su))
km_6_SU = KMeans(6).fit(X_SU)
km_6_SUv = KMeans(6).fit(df_SU)
True_lables5_su =km_6_SUv.labels_
labels5_su = km_6_SUv.predict(df_SU)
v_scores_su.append(v_measure_score(df_SU['4'], labels5_su))
km_7_SU = KMeans(7).fit(X_SU)
km_7_SUv = KMeans(7).fit(df_SU)
True_lables6_su =km_7_SUv.labels_
labels6_su = km_7_SUv.predict(df_SU)
v_scores_su.append(v_measure_score(df_SU['4'], labels6_su))
km_8_SU = KMeans(8).fit(X_SU)
km_8_SUv = KMeans(8).fit(df_SU)
True_lables7_su =km_8_SUv.labels_
labels7_su = km_8_SUv.predict(df_SU)
v_scores_su.append(v_measure_score(df_SU['4'], labels7_su))
v_scores_sp = []
N_Clusters = [2, 3, 4, 5, 6, 7, 8]
km_2_SP = KMeans(2).fit(X_SP)
km_2_SPv = KMeans(2).fit(df_SP)
True_lables1_sp =km_2_SPv.labels_
labels1_sp = km_2_SPv.predict(df_SP)
v_scores_sp.append(v_measure_score(df_SP['1'], labels1_sp))
km_3_SP = KMeans(3).fit(X_SP)
km_3_SPv = KMeans(3).fit(df_SP)
True_lables2_sp =km_3_SPv.labels_
labels2_sp = km_3_SPv.predict(df_SP)
v_scores_sp.append(v_measure_score(df_SP['1'], labels2_sp))
km_4_SP = KMeans(4).fit(X_SP)
km_4_SPv = KMeans(4).fit(df_SP)
True_lables3_sp =km_4_SPv.labels_
labels3_sp = km_4_SPv.predict(df_SP)
v_scores_sp.append(v_measure_score(df_SP['1'], labels3_sp))
km_5_SP = KMeans(5).fit(X_SP)
km_5_SPv = KMeans(5).fit(df_SP)
True_lables4_sp =km_5_SPv.labels_
labels4_sp = km_5_SPv.predict(df_SP)
v_scores_sp.append(v_measure_score(df_SP['1'], labels4_sp))
km_6_SP = KMeans(6).fit(X_SP)
km_6_SPv = KMeans(6).fit(df_SP)
True_lables5_sp =km_6_SPv.labels_
labels5_sp = km_6_SPv.predict(df_SP)
v_scores_sp.append(v_measure_score(df_SP['1'], labels5_sp))
km_7_SP = KMeans(7).fit(X_SP)
km_7_SPv = KMeans(7).fit(df_SP)
True_lables6_sp =km_7_SPv.labels_
labels6_sp = km_7_SPv.predict(df_SP)
v_scores_sp.append(v_measure_score(df_SP['1'], labels6_sp))
km_8_SP = KMeans(8).fit(X_SP)
km_8_SPv = KMeans(8).fit(df_SP)
True_lables7_sp =km_8_SPv.labels_
labels7_sp = km_8_SPv.predict(df_SP)
v_scores_sp.append(v_measure_score(df_SP['1'], labels7_sp))
#Plotting a Bar Graph to compare the models
plt.bar(N_Clusters, v_scores)
plt.xlabel('Number of Clusters')
plt.ylabel('V-Measure Score')
plt.title('Comparison of different Clustering Models')
plt.show()
print('k = 3 the score is ',silhouette_score(X_A, km_3_A.labels_, metric = 'euclidean'),'\n',
'k = 4 the score is ',silhouette_score(X_A, km_4_A.labels_, metric = 'euclidean'),'\n',
'k = 5 the score is ',silhouette_score(X_A, km_5_A.labels_, metric = 'euclidean'),'\n',
'k = 6 the score is ',silhouette_score(X_A, km_6_A.labels_, metric = 'euclidean'),'\n',
'k = 7 the score is ',silhouette_score(X_A, km_7_A.labels_, metric = 'euclidean'),'\n',
'k = 8 the score is ',silhouette_score(X_A, km_8_A.labels_, metric = 'euclidean'))
#Plotting a Bar Graph to compare the models
plt.bar(N_Clusters, v_scores_su)
plt.xlabel('Number of Clusters')
plt.ylabel('V-Measure Score')
plt.title('Comparison of different Clustering Models')
plt.show()
print('k = 3 the score is ',silhouette_score(X_SU, km_3_SU.labels_, metric = 'euclidean'),'\n',
'k = 4 the score is ',silhouette_score(X_SU, km_4_SU.labels_, metric = 'euclidean'),'\n',
'k = 5 the score is ',silhouette_score(X_SU, km_5_SU.labels_, metric = 'euclidean'),'\n',
'k = 6 the score is ',silhouette_score(X_SU, km_6_SU.labels_, metric = 'euclidean'),'\n',
'k = 7 the score is ',silhouette_score(X_SU, km_7_SU.labels_, metric = 'euclidean'),'\n',
'k = 8 the score is ',silhouette_score(X_SU, km_8_SU.labels_, metric = 'euclidean'))
#Plotting a Bar Graph to compare the models
plt.bar(N_Clusters, v_scores_w)
plt.xlabel('Number of Clusters')
plt.ylabel('V-Measure Score')
plt.title('Comparison of different Clustering Models')
plt.show()
print('k = 3 the score is ',silhouette_score(X_W, km_3_W.labels_, metric = 'euclidean'),'\n',
'k = 4 the score is ',silhouette_score(X_W, km_4_W.labels_, metric = 'euclidean'),'\n',
'k = 5 the score is ',silhouette_score(X_W, km_5_W.labels_, metric = 'euclidean'),'\n',
'k = 6 the score is ',silhouette_score(X_W, km_6_W.labels_, metric = 'euclidean'),'\n',
'k = 7 the score is ',silhouette_score(X_W, km_7_W.labels_, metric = 'euclidean'),'\n',
'k = 8 the score is ',silhouette_score(X_W, km_8_W.labels_, metric = 'euclidean'))
#Plotting a Bar Graph to compare the models
plt.bar(N_Clusters, v_scores_sp)
plt.xlabel('Number of Clusters')
plt.ylabel('V-Measure Score')
plt.title('Comparison of different Clustering Models')
plt.show()
print('k = 3 the score is ',silhouette_score(X_SP, km_3_SP.labels_, metric = 'euclidean'),'\n',
'k = 4 the score is ',silhouette_score(X_SP, km_4_SP.labels_, metric = 'euclidean'),'\n',
'k = 5 the score is ',silhouette_score(X_SP, km_5_SP.labels_, metric = 'euclidean'),'\n',
'k = 6 the score is ',silhouette_score(X_SP, km_6_SP.labels_, metric = 'euclidean'),'\n',
'k = 7 the score is ',silhouette_score(X_SP, km_7_SP.labels_, metric = 'euclidean'),'\n',
'k = 8 the score is ',silhouette_score(X_SP, km_8_SP.labels_, metric = 'euclidean'))
plt.plot(X_A.columns, km_4_A.cluster_centers_[0], alpha=0.7, lw=1, color = 'blue',linestyle='dotted')
plt.gca()
plt.tight_layout()
#plt.legend()
plt.xlabel('Timeline')
plt.ylabel('Energy Consumption (kW)')
plt.title('Cluster 0')
plt.plot(X_A.columns, km_4_A.cluster_centers_[1], alpha=0.7, lw=1, color = 'green',linestyle='dotted')
plt.gca()
plt.tight_layout()
#plt.legend()
plt.xlabel('Timeline')
plt.ylabel('Energy Consumption (kW)')
plt.title('Cluster 1')
plt.plot(X_A.columns, km_4_A.cluster_centers_[2], alpha=0.7, lw=1, color = 'red',linestyle='dotted')
plt.gca()
plt.tight_layout()
#plt.legend()
plt.xlabel('Timeline')
plt.ylabel('Energy Consumption (kW)')
plt.title('Cluster 2')
plt.plot(X_A.columns, km_4_A.cluster_centers_[3], alpha=0.7, lw=1, color = 'orange',linestyle='dotted')
plt.gca()
plt.tight_layout()
#plt.legend()
plt.xlabel('Timeline')
plt.ylabel('Energy Consumption (kW)')
plt.title('Cluster 3')
#plt.figure(figsize=(5,5))
plt.plot(X_A.columns, km_4_A.cluster_centers_[1], alpha=0.8, lw=2, color = 'green')
plt.plot(X_A.columns, km_4_A.cluster_centers_[2], alpha=0.8, lw=2, color = 'red')
plt.plot(X_A.columns, km_4_A.cluster_centers_[3], alpha=0.8, lw=1, color = 'orange')
plt.plot(X_A.columns, km_4_A.cluster_centers_[0], alpha=0.8, lw=1, color = 'blue')
plt.gca()
plt.tight_layout()
#plt.legend()
plt.xlabel('Timeline')
plt.ylabel('Energy Consumption (kW)')
plt.title('All Clusters overlapping')
plt.figure(figsize=(5,5))
plt.plot(X_W.columns, km_4_W.cluster_centers_[0], alpha=0.8, lw=1, color = 'blue')
plt.plot(X_W.columns, km_4_W.cluster_centers_[1], alpha=0.8, lw=2, color = 'green')
plt.plot(X_W.columns, km_4_W.cluster_centers_[2], alpha=0.8, lw=2, color = 'red')
plt.plot(X_W.columns, km_4_W.cluster_centers_[3], alpha=0.8, lw=1, color = 'orange')
plt.gca()
plt.tight_layout()
#plt.legend()
plt.xlabel('Timeline')
plt.ylabel('Energy Consumption (kW)')
plt.title('All Clusters overlapping')
plt.figure(figsize=(10,7))
plt.plot(X_SU.columns, km_4_SU.cluster_centers_[3], alpha=0.8, lw=1, color = 'orange')
plt.plot(X_SU.columns, km_4_SU.cluster_centers_[1], alpha=0.8, lw=2, color = 'green')
plt.plot(X_SU.columns, km_4_SU.cluster_centers_[2], alpha=0.8, lw=2, color = 'red')
plt.plot(X_SU.columns, km_4_SU.cluster_centers_[0], alpha=0.8, lw=1, color = 'blue')
plt.gca()
plt.tight_layout()
#plt.legend()
plt.xlabel('Timeline')
plt.ylabel('Energy Consumption (kW)')
plt.title('All Clusters overlapping')
plt.figure(figsize=(10,7))
plt.plot(X_SP.columns, km_4_SP.cluster_centers_[1], alpha=0.8, lw=2, color = 'green')
plt.plot(X_SP.columns, km_4_SP.cluster_centers_[2], alpha=0.8, lw=2, color = 'red')
plt.plot(X_SP.columns, km_4_SP.cluster_centers_[0], alpha=0.8, lw=1, color = 'blue')
plt.plot(X_SP.columns, km_4_SP.cluster_centers_[3], alpha=0.8, lw=1, color = 'orange')
plt.gca()
plt.tight_layout()
#plt.legend()
plt.xlabel('Timeline')
plt.ylabel('Energy Consumption (kW)')
plt.title('All Clusters overlapping')
%%time
hc_A = AgglomerativeClustering(n_clusters = 4, affinity = 'euclidean', linkage ='ward')
X_hc_A=hc_A.fit(X_A)
pd.Series.value_counts(X_hc_A.labels_)
estimate_bandwidth(X_A.values, quantile=0.5)
ms_A = MeanShift(bandwidth=39, cluster_all=True).fit(X_A)
pd.Series.value_counts(ms_A.labels_)
#km_4_W = KMeans(4).fit(X_W)
#pd.Series.value_counts(km_4_W.labels_)
km_4_A = KMeans(4).fit(X_A)
pd.Series.value_counts(km_4_A.labels_)
X_A['cluster'] = km_4_A.labels_
#X_SU['cluster'] = km_4_SU.labels_
#X_W['cluster'] = km_4_W.labels_
#X_SP['cluster'] = km_4_SP.labels_
X_A_C1 = X_A[X_A.cluster == 0]
X_A_C2 = X_A[X_A.cluster == 1]
X_A_C3 = X_A[X_A.cluster == 2]
X_A_C4 = X_A[X_A.cluster == 3]
#X_A_C5 = X_A[X_A.cluster == 4]
#X_A_C6 = X_A[X_A.cluster == 5]
X_A_C1 = X_A_C1.drop(columns = 'cluster')
X_A_C1 = X_A_C1.transpose()
X_A_C1.head()
X_A_C1 = X_A_C1.values
cap = np.percentile(X_A_C1, 97)
X_A_C1[X_A_C1 > cap] = cap
###########
#scaler = MinMaxScaler(feature_range=(0, 1))
#Xtrain = scaler.fit(Xtrain.reshape(0, 1))
#X_A_C1 = scaler.fit_transform(X_A_C1)
training_size=int(X_A_C1.shape[0]*0.80)
test_size=(X_A_C1.shape[0])-training_size
train,test=X_A_C1[0:training_size],X_A_C1[training_size:(X_A_C1.shape[0])]
def get_batches(data, input_interval, target_interval, output_step_offset):
batched_data_x = []
batched_data_y = []
for i in range(input_interval, (len(data) - target_interval - output_step_offset)):
batched_data_x.append(data[i-input_interval:i])
batched_data_y.append(data[i+output_step_offset:i+target_interval+output_step_offset])
batched_data_x, batched_data_y = np.array(batched_data_x), np.array(batched_data_y)
return batched_data_x, batched_data_y
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape)
print(testX.shape, testY.shape)
###Building a sequential network:
Model_1 = models.Sequential()
Model_1.add(layers.Dense(500, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model_1.add(Dropout(.2))
Model_1.add(BatchNormalization())
Model_1.add(Dense(300))
Model_1.add(Dropout(.2))
Model_1.add(BatchNormalization())
Model_1.add(layers.Dense(200, activation='relu'))
Model_1.add(Dropout(.2))
Model_1.add(BatchNormalization())
Model_1.add((Dense(trainX.shape[2])))
Model_1.compile(optimizer= 'adam', loss='mse', metrics=['mae'])
Model_1.summary()
model_train = Model_1.fit(trainX,trainY, epochs=30, validation_split = 0.10, batch_size=64)
Seq_train = Model_1.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model_1.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
def rmse(actual, pred):
return np.sqrt(((pred - actual) ** 2).mean())
def mae(actual, pred):
return np.mean(np.abs(actual - pred))
testMAE = np.mean(mae(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
plt.imshow(testY[:48,47,:])
plt.show()
plt.imshow(Seq_test[:48,47,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,1,1], marker='.', label="actual")
plt.plot(aa, Seq_test[:,1,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
lr_decay = callbacks.LearningRateScheduler(schedule=lambda epoch: 0.001 * (0.80 ** epoch))
model = Sequential()
model.add(LSTM(300, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
model.add(Dropout(.1))
#model.add(LSTM(100, activation='relu', return_sequences=True))
#model.add(Dropout(.2))
#model.add(Dropout(.01))
#model.add(LSTM(50, activation='relu', return_sequences = True))
#model.add(Dropout(.01))
model.add(Dense(trainX.shape[2]))
#sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9), 'optimizers.Adam(lr=0.01)'
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
model.summary()
# fit model
history_A_C1 = model.fit(trainX,trainY, epochs=30, validation_split = 0.05,batch_size = 64, callbacks=[lr_decay])
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_A_C1.history['loss'], label='train')
plt.plot(history_A_C1.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
#fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
#plt.plot(history_A_C1.history['mae'], label='train')
#plt.plot(history_A_C1.history['val_mae'], label='val')
#plt.ylabel('Pérdida')
#plt.xlabel('Epoch')
#plt.legend()
#plt.show()
testingtrain_C1 = model.predict(trainX, verbose = 1)
print(testingtrain_C1[0], testingtrain_C1.shape)
testingtest_C1 = model.predict(testX, verbose = 1)
print(testingtest_C1[0], testingtest_C1.shape)
def rmse(actual, pred):
return np.sqrt(((pred - actual) ** 2).mean())
def mae(actual, pred):
return np.mean(np.abs(actual - pred))
trainScore = math.sqrt(mean_squared_error(trainY[:,1,:], testingtrain_C1[:,1,:]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest_C1[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
trainMAE = np.mean(mae(trainY[:,1,:], testingtrain_C1[:,1,:]))
print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], testingtest_C1[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
X_A_C2 = X_A_C2.drop(columns = 'cluster')
X_A_C2 = X_A_C2.transpose()
X_A_C2.head()
X_A_C2 = X_A_C2.values
cap = np.percentile(X_A_C2, 97)
X_A_C2[X_A_C2 > cap] = cap
training_size=int(X_A_C2.shape[0]*0.80)
test_size=(X_A_C2.shape[0])-training_size
train,test=X_A_C2[0:training_size],X_A_C2[training_size:(X_A_C2.shape[0])]
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape, '\n',
testX.shape, testY.shape)
###Building a sequential network:
Model_2 = models.Sequential()
Model_2.add(layers.Dense(600, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model_2.add(Dropout(.01))
Model_2.add(BatchNormalization())
Model_2.add(Dense(400))
Model_2.add(Dropout(.01))
Model_2.add(BatchNormalization())
Model_2.add(Dense(200))
Model_2.add(Dropout(.01))
Model_2.add(BatchNormalization())
Model_2.add((Dense(trainX.shape[2])))
Model_2.compile(optimizer= optimizers.Adam(lr=0.001), loss='mse', metrics=['mae'])
Model_2.summary()
model_train = Model_2.fit(trainX,trainY, epochs=30, validation_split = 0.10, batch_size=64)
Seq_train = Model_2.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model_2.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
#trainScore = math.sqrt(mean_squared_error(trainY_RMSE, testingtrain_C1))
#print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:48,1,1], Seq_test[:48,1,1]))
print('Test Score: %.2f RMSE' % (testScore))
#trainMAE = np.mean(mae(trainY[:48,1,1], testingtrain_C2[:48,1,1]))
#print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:48,1,1], Seq_test[:48,1,1]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,47,:])
plt.show()
plt.imshow(Seq_test[:48,47,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,47,1], marker='.', label="actual")
plt.plot(aa, Seq_test[:,47,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
model = Sequential()
model.add(LSTM(200, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
#model.add(Dense(512))
#model.add(Dense(84))
#model.add(Dropout(.01))
#model.add(LSTM(50, activation='relu', return_sequences = True))
#model.add(Dropout(.01))
model.add(Dense(trainX.shape[2]))
#sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9), 'optimizers.Adam(lr=0.01)'
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
model.summary()
# fit model
history_C2 = model.fit(trainX,trainY, epochs=30,
validation_split = 0.05,
batch_size = 64,
callbacks=[lr_decay])
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_C2.history['loss'], label='train')
plt.plot(history_C2.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
testingtrain_C2 = model.predict(trainX, verbose = 1)
print(testingtrain_C2[0], testingtrain_C2.shape)
testingtest_C2 = model.predict(testX, verbose = 1)
print(testingtest_C2[0], testingtest_C2.shape)
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest_C2[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
#trainMAE = np.mean(mae(trainY_RMSE, testingtrain_C2))
#print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], testingtest_C2[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,1,:])
plt.show()
plt.imshow(testingtest_C2[:48,1,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,47,1], marker='.', label="actual")
plt.plot(aa, testingtest_C2[:,47,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
########cluster 3
X_A_C3 = X_A_C3.drop(columns = 'cluster')
X_A_C3 = X_A_C3.transpose()
X_A_C3.head()
X_A_C3 = X_A_C3.values
cap = np.percentile(X_A_C2, 97)
X_A_C2[X_A_C2 > cap] = cap
training_size=int(X_A_C3.shape[0]*0.80)
test_size=(X_A_C3.shape[0])-training_size
train,test=X_A_C3[0:training_size],X_A_C3[training_size:(X_A_C3.shape[0])]
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape, '\n',
testX.shape, testY.shape)
###Building a sequential network:
Model_3 = models.Sequential()
Model_3.add(layers.Dense(200, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model_3.add(Dropout(.2))
Model_3.add(BatchNormalization())
Model_3.add(Dense(100))
Model_3.add(Dropout(.2))
Model_3.add(BatchNormalization())
Model_3.add((Dense(trainX.shape[2])))
Model_3.compile(optimizer= optimizers.Adam(lr=0.001), loss='mse', metrics=['mae'])
Model_3.summary()
model_train = Model_3.fit(trainX,trainY, epochs=30, validation_split = 0.05, batch_size=64)
Seq_train = Model_3.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model_3.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
#trainScore = math.sqrt(mean_squared_error(trainY_RMSE, testingtrain_C1))
#print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:48,1,1], Seq_test[:48,1,1]))
print('Test Score: %.2f RMSE' % (testScore))
#trainMAE = np.mean(mae(trainY[:48,1,1], testingtrain_C2[:48,1,1]))
#print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:48,1,1], Seq_test[:48,1,1]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,47,:])
plt.show()
plt.imshow(Seq_test[:48,47,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,47,1], marker='.', label="actual")
plt.plot(aa, Seq_test[:,47,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
model = Sequential()
model.add(LSTM(100, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
model.add(Dropout(.2))
#model.add(LSTM(100, activation='relu', return_sequences=True))
#model.add(Dropout(.1))
model.add(Dense(trainX.shape[2]))
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
model.summary()
# fit model
history_C3 = model.fit(trainX,trainY, epochs=30,
validation_split = 0.05,
batch_size = 64,
callbacks=[lr_decay])
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_C3.history['loss'], label='train')
plt.plot(history_C3.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
testingtrain_C3 = model.predict(trainX, verbose = 1)
print(testingtrain_C3[0], testingtrain_C3.shape)
testingtest_C3 = model.predict(testX, verbose = 1)
print(testingtest_C3[0], testingtest_C3.shape)
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest_C3[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
testMAE = np.mean(mae(testY[:,1,:], testingtest_C3[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,1,:])
plt.show()
plt.imshow(testingtest_C3[:48,1,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,1,1], marker='.', label="actual")
plt.plot(aa, testingtest_C3[:,1,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
########cluster 4
X_A_C4 = X_A_C4.drop(columns = 'cluster')
X_A_C4 = X_A_C4.transpose()
X_A_C4.head()
X_A_C4 = X_A_C4.values
cap = np.percentile(X_A_C4, 97)
X_A_C4[X_A_C4 > cap] = cap
training_size=int(X_A_C4.shape[0]*0.80)
test_size=(X_A_C4.shape[0])-training_size
train,test=X_A_C4[0:training_size],X_A_C4[training_size:(X_A_C4.shape[0])]
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape, '\n',
testX.shape, testY.shape)
###Building a sequential network:
Model_4 = models.Sequential()
Model_4.add(layers.Dense(150, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model_4.add(Dropout(0.5))
Model_4.add(BatchNormalization())
Model_4.add(layers.Dense(75, activation='relu'))
Model_4.add(Dropout(0.5))
Model_4.add(BatchNormalization())
Model_4.add((Dense(trainX.shape[2])))
Model_4.compile(optimizer= optimizers.Adam(lr=0.001), loss='mse', metrics=['mae'])
Model_4.summary()
model_train = Model_4.fit(trainX,trainY, epochs=30, validation_split = 0.10, batch_size=64)
Seq_train = Model_4.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model_4.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
#trainScore = math.sqrt(mean_squared_error(trainY_RMSE, testingtrain_C1))
#print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:48,1,1], Seq_test[:48,1,1]))
print('Test Score: %.2f RMSE' % (testScore))
#trainMAE = np.mean(mae(trainY[:48,1,1], testingtrain_C2[:48,1,1]))
#print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:48,1,1], Seq_test[:48,1,1]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,47,:])
plt.show()
plt.imshow(Seq_test[:48,47,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,47,1], marker='.', label="actual")
plt.plot(aa, Seq_test[:,47,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
model = Sequential()
model.add(LSTM(75, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
#model.add(Dropout(.01))
model.add((Dense(trainX.shape[2])))
#sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9), 'optimizers.Adam(lr=0.01)'
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
model.summary()
# fit model
history_C4 = model.fit(trainX,trainY, epochs=30, validation_split = 0.10, batch_size=32, callbacks=[lr_decay])
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_C4.history['loss'], label='train')
plt.plot(history_C4.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
testingtrain_C4 = model.predict(trainX, verbose = 1)
print(testingtrain_C4[0], testingtrain_C4.shape)
testingtest_C4 = model.predict(testX, verbose = 1)
print(testingtest_C4[0], testingtest_C4.shape)
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest_C4[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
testMAE = np.mean(mae(testY[:,1,:], testingtest_C4[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,1,:])
plt.show()
plt.imshow(testingtest_C4[:48,1,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,1,1], marker='.', label="actual")
plt.plot(aa, testingtest_C4[:,1,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
km_4_W = KMeans(4).fit(X_W)
pd.Series.value_counts(km_4_W.labels_)
X_W['cluster'] = km_4_W.labels_
##############WINTER
X_W_C1 = X_W[X_W.cluster == 0]
X_W_C2 = X_W[X_W.cluster == 1]
X_W_C3 = X_W[X_W.cluster == 2]
X_W_C4 = X_W[X_W.cluster == 3]
X_W_C1 = X_W_C1.drop(columns = 'cluster')
X_W_C1 = X_W_C1.transpose()
X_W_C1.head()
#scaler = MinMaxScaler(feature_range=(0, 1))
#Xtrain = scaler.fit(Xtrain.reshape(0, 1))
#X_W_C1 = scaler.fit_transform(X_W_C1)
X_W_C1 = X_W_C1.values
cap = np.percentile(X_W_C1, 97)
X_W_C1[X_W_C1 > cap] = cap
training_size=int(X_W_C1.shape[0]*0.80)
test_size=(X_W_C1.shape[0])-training_size
train,test=X_W_C1[0:training_size],X_W_C1[training_size:(X_W_C1.shape[0])]
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape)
print(testX.shape, testY.shape)
from keras.regularizers import l2
Model_1 = models.Sequential()
Model_1.add(layers.Dense(500, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2]), kernel_regularizer=l2(0.001)))
Model_1.add(Dropout(.2))
Model_1.add(BatchNormalization())
Model_1.add(layers.Dense(300, activation='relu'))
Model_1.add(Dropout(.2))
Model_1.add(BatchNormalization())
Model_1.add((Dense(trainX.shape[2])))
Model_1.compile(optimizer= optimizers.Adam(lr=0.001), loss='mse', metrics=['mae'])
Model_1.summary()
model_train = Model_1.fit(trainX,trainY, epochs=30, validation_split = 0.10, batch_size = 64)
Seq_train = Model_1.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model_1.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
testScore = math.sqrt(mean_squared_error(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
#trainScore = math.sqrt(mean_squared_error(trainY[:,1,:], Seq_train[:,1,:]))
#print('Test Score: %.2f RMSE' % (trainScore))
#trainMAE = np.mean(mae(trainY[:,1,:], Seq_train[:,1,:]))
#print('Test Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,47,:])
plt.show()
plt.imshow(Seq_test[:48,47,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,1,1], marker='.', label="actual")
plt.plot(aa, Seq_test[:,1,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
model = Sequential()
model.add(LSTM(200, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
#model.add(Dense(30))
#model.add(Dropout(.5))
#model.add(BatchNormalization())
model.add(Dense(trainX.shape[2]))
#sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9), 'optimizers.Adam(lr=0.01)'
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
model.summary()
# fit model
history_W_C1 = model.fit(trainX,trainY, epochs=30, validation_split = 0.10, batch_size=64, callbacks=[lr_decay])
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_W_C1.history['loss'], label='train')
plt.plot(history_W_C1.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
testingtrain_C1 = model.predict(trainX, verbose = 1)
print(testingtrain_C1[0], testingtrain_C1.shape)
testingtest_C1 = model.predict(testX, verbose = 1)
print(testingtest_C1[0], testingtest_C1.shape)
def rmse(actual, pred):
return np.sqrt(((pred - actual) ** 2).mean())
def mae(actual, pred):
return np.mean(np.abs(actual - pred))
trainScore = math.sqrt(mean_squared_error(trainY[:,1,:], testingtrain_C1[:,1,:]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest_C1[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
trainMAE = np.mean(mae(trainY[:,1,:], testingtrain_C1[:,1,:]))
print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], testingtest_C1[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:47,47,:])
plt.show()
plt.imshow(testingtest_C1[:47,47,:])
plt.show()
aa=[x for x in range(200)]
plt.figure(figsize=(20,5))
plt.plot(aa, trainY[:200,47,13], marker='.', label="actual")
plt.plot(aa, testingtrain_C1[:200,47,13], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
X_W_C2 = X_W_C2.drop(columns = 'cluster')
X_W_C2 = X_W_C2.transpose()
X_W_C2.head()
X_W_C2 = X_W_C2.values
cap = np.percentile(X_W_C2, 97)
X_W_C2[X_W_C2 > cap] = cap
training_size=int(X_W_C2.shape[0]*0.80)
test_size=(X_W_C2.shape[0])-training_size
train,test=X_W_C2[0:training_size],X_W_C2[training_size:(X_W_C2.shape[0])]
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape, '\n',
testX.shape, testY.shape)
Model_2 = models.Sequential()
Model_2.add(layers.Dense(400, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model_2.add(Dropout(.2))
Model_2.add(BatchNormalization())
#Model_2.add(layers.Dense(400, activation='relu'))
#Model_2.add(Dropout(.2))
Model_2.add(layers.Dense(200, activation='relu'))
Model_2.add(Dropout(.2))
Model_2.add(BatchNormalization())
Model_2.add((Dense(trainX.shape[2])))
Model_2.compile(optimizer= optimizers.Adam(lr=0.001), loss='mse', metrics=['mae'])
Model_2.summary()
model_train = Model_2.fit(trainX,trainY, epochs=30, validation_split = 0.10, batch_size=64)
Seq_train = Model_2.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model_2.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
#trainScore = math.sqrt(mean_squared_error(trainY_RMSE, testingtrain_C1))
#print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:48,1,1], Seq_test[:48,1,1]))
print('Test Score: %.2f RMSE' % (testScore))
#trainMAE = np.mean(mae(trainY[:48,1,1], testingtrain_C2[:48,1,1]))
#print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:48,1,1], Seq_test[:48,1,1]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,47,:])
plt.show()
plt.imshow(Seq_test[:48,47,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,47,1], marker='.', label="actual")
plt.plot(aa, Seq_test[:,47,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
model = Sequential()
model.add(LSTM(200, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
#model.add(Dense(400))
model.add(Dropout(.5))
model.add(Dense(trainX.shape[2]))
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
#optimizers.Adam(lr=0.001)
model.summary()
# fit model
history_C2 = model.fit(trainX,trainY, epochs=30, validation_split = 0.05, batch_size=64, callbacks=[lr_decay])
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_C2.history['loss'], label='train')
plt.plot(history_C2.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
testingtrain_C2 = model.predict(trainX, verbose = 1)
print(testingtrain_C2[0], testingtrain_C2.shape)
testingtest_C2 = model.predict(testX, verbose = 1)
print(testingtest_C2[0], testingtest_C2.shape)
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest_C2[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
testScore = math.sqrt(mean_squared_error(trainY[:,1,:], testingtrain_C2[:,1,:]))
print('Train Score: %.2f RMSE' % (testScore))
trainMAE = np.mean(mae(trainY, testingtrain_C2))
print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY, testingtest_C2))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,1,:])
plt.show()
plt.imshow(testingtest_C2[:48,1,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,1,1], marker='.', label="actual")
plt.plot(aa, testingtest_C2[:,1,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
########cluster 3
X_W_C3 = X_W_C3.drop(columns = 'cluster')
X_W_C3 = X_W_C3.transpose()
X_W_C3.head()
X_W_C3 = X_W_C3.values
cap = np.percentile(X_W_C2, 97)
X_W_C2[X_W_C2 > cap] = cap
training_size=int(X_W_C3.shape[0]*0.80)
test_size=(X_W_C3.shape[0])-training_size
train,test=X_W_C3[0:training_size],X_W_C3[training_size:(X_W_C3.shape[0])]
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape, '\n',
testX.shape, testY.shape)
###Building a sequential network:
Model_3 = models.Sequential()
Model_3.add(layers.Dense(100, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model_3.add(Dropout(.2))
Model_3.add(layers.Dense(50, activation='relu'))
Model_3.add(Dropout(.2))
Model_3.add((Dense(trainX.shape[2])))
Model_3.compile(optimizer= optimizers.Adam(lr=0.001), loss='mse', metrics=['mae'])
Model_3.summary()
#optimizers.Adam(lr=0.001)
model_train = Model_3.fit(trainX,trainY, epochs=30, validation_split = 0.05, batch_size=32)
Seq_train = Model_3.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model_3.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
testScore = math.sqrt(mean_squared_error(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
#trainMAE = np.mean(mae(trainY[:48,1,1], testingtrain_C2[:48,1,1]))
#print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,47,:])
plt.show()
plt.imshow(Seq_test[:48,47,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,47,1], marker='.', label="actual")
plt.plot(aa, Seq_test[:,47,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
model = Sequential()
model.add(LSTM(60, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
#model.add(Dense(100))
#model.add(Dropout(.2))
model.add(Dense(trainX.shape[2]))
#model.add(BatchNormalization())
#model.add(Dropout(.01))
#sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9), 'optimizers.Adam(lr=0.01)'
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
model.summary()
# fit model
history_C3 = model.fit(trainX,trainY, epochs=30, batch_size=32, validation_split = 0.05, callbacks=[lr_decay])
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_C3.history['loss'], label='train')
plt.plot(history_C3.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
testingtrain_C3 = model.predict(trainX, verbose = 1)
print(testingtrain_C3[0], testingtrain_C3.shape)
testingtest_C3 = model.predict(testX, verbose = 1)
print(testingtest_C3[0], testingtest_C3.shape)
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest_C3[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
trainScore = math.sqrt(mean_squared_error(trainY[:,1,:], testingtrain_C3[:,1,:]))
print('Test Score: %.2f RMSE' % (trainScore))
testMAE = np.mean(mae(testY[:,1,:], testingtest_C3[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
trainMAE = np.mean(mae(trainY[:,1,:], testingtrain_C3[:,1,:]))
print('Test Score: %.2f MAE' % (trainMAE))
plt.imshow(testY[:48,1,:])
plt.show()
plt.imshow(testingtest_C3[:48,1,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,1,1], marker='.', label="actual")
plt.plot(aa, testingtest_C3[:,1,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
########cluster 4
X_W_C4 = X_W_C4.drop(columns = 'cluster')
X_W_C4 = X_W_C4.transpose()
X_W_C4.head()
X_W_C4 = X_W_C4.values
cap = np.percentile(X_W_C4, 97)
X_W_C4[X_W_C4 > cap] = cap
training_size=int(X_W_C4.shape[0]*0.80)
test_size=(X_W_C4.shape[0])-training_size
train,test=X_W_C4[0:training_size],X_W_C4[training_size:(X_W_C4.shape[0])]
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape, '\n',
testX.shape, testY.shape)
###Building a sequential network:
Model_4 = models.Sequential()
Model_4.add(layers.Dense(200, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model_4.add(Dropout(0.2))
Model_4.add(BatchNormalization())
Model_4.add(layers.Dense(100, activation='relu'))
Model_4.add(Dropout(0.2))
Model_4.add(BatchNormalization())
Model_4.add((Dense(trainX.shape[2])))
Model_4.compile(optimizer= optimizers.Adam(lr=0.001), loss='mse', metrics=['mae'])
Model_4.summary()
model_train = Model_4.fit(trainX,trainY, epochs=30, validation_split = 0.05, batch_size=32)
Seq_train = Model_4.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model_4.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
#trainScore = math.sqrt(mean_squared_error(trainY_RMSE, testingtrain_C1))
#print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
#trainMAE = np.mean(mae(trainY[:48,1,1], testingtrain_C2[:48,1,1]))
#print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,47,:])
plt.show()
plt.imshow(Seq_test[:48,47,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,47,1], marker='.', label="actual")
plt.plot(aa, Seq_test[:,47,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
from keras.layers.core import Dense, Activation, Dropout
model = Sequential()
model.add(LSTM(50, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
model.add(Dense(trainX.shape[2]))
#sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9), 'optimizers.Adam(lr=0.01)'
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
model.summary()
# fit model
history_C4 = model.fit(trainX, trainY, epochs=30, validation_split = 0.05, batch_size=32, callbacks=[lr_decay])
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_C4.history['loss'], label='train')
plt.plot(history_C4.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
testingtrain_C4 = model.predict(trainX, verbose = 1)
print(testingtrain_C4[0], testingtrain_C4.shape)
testingtest_C4 = model.predict(testX, verbose = 1)
print(testingtest_C4[0], testingtest_C4.shape)
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest_C4[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
testMAE = np.mean(mae(testY[:,1,:], testingtest_C4[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,1,:])
plt.show()
plt.imshow(testingtest_C4[:48,1,:])
plt.show()
aa=[x for x in range(200)]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:200,1,1], marker='.', label="actual")
plt.plot(aa, testingtest_C4[:200,1,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
###########SUMMER
km_4_SU = KMeans(4).fit(X_SU)
pd.Series.value_counts(km_4_SU.labels_)
X_SU['cluster'] = km_4_SU.labels_
X_SU_C1 = X_SU[X_SU.cluster == 0]
X_SU_C2 = X_SU[X_SU.cluster == 1]
X_SU_C3 = X_SU[X_SU.cluster == 2]
X_SU_C4 = X_SU[X_SU.cluster == 3]
#X_A_C5 = X_A[X_A.cluster == 4]
#X_A_C6 = X_A[X_A.cluster == 5]
X_SU_C1 = X_SU_C1.drop(columns = 'cluster')
X_SU_C1 = X_SU_C1.transpose()
X_SU_C1.head()
X_SU_C1 = X_SU_C1.values
cap = np.percentile(X_SU_C1, 97)
X_SU_C1[X_SU_C1 > cap] = cap
###########
#scaler = MinMaxScaler(feature_range=(0, 1))
#Xtrain = scaler.fit(Xtrain.reshape(0, 1))
#X_A_C1 = scaler.fit_transform(X_A_C1)
training_size=int(X_SU_C1.shape[0]*0.80)
test_size=(X_SU_C1.shape[0])-training_size
train,test=X_SU_C1[0:training_size],X_SU_C1[training_size:(X_SU_C1.shape[0])]
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape)
print(testX.shape, testY.shape)
###Building a sequential network:
Model_1 = models.Sequential()
Model_1.add(layers.Dense(600, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model_1.add(Dropout(0.2))
Model_1.add(BatchNormalization())
Model_1.add(layers.Dense(300, activation='relu'))
Model_1.add(Dropout(0.2))
Model_1.add(BatchNormalization())
Model_1.add((Dense(trainX.shape[2])))
Model_1.compile(optimizer= optimizers.Adam(lr=0.001), loss='mse', metrics=['mae'])
Model_1.summary()
model_train = Model_1.fit(trainX,trainY, epochs=30, batch_size = 32, validation_split = 0.10)
Seq_train = Model_1.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model_1.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
testMAE = np.mean(mae(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
plt.imshow(testY[:48,47,:])
plt.show()
plt.imshow(Seq_test[:48,47,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,47,:1], marker='.', label="actual")
plt.plot(aa, Seq_test[:,47,:1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
model = Sequential()
model.add(LSTM(200, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
#model.add(Dense(84))
#model.add(Dropout(.2))
#model.add(LSTM(100, activation='relu', return_sequences = True))
#model.add(Dropout(.01))
model.add(Dense(trainX.shape[2]))
#sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9), 'optimizers.Adam(lr=0.01)'
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
model.summary()
# fit model
history_SU_C1 = model.fit(trainX,trainY, epochs=30, validation_split = 0.05,
batch_size = 64,
callbacks=[lr_decay])
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_SU_C1.history['loss'], label='train')
plt.plot(history_SU_C1.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
testingtrain_C1 = model.predict(trainX, verbose = 1)
print(testingtrain_C1[0], testingtrain_C1.shape)
testingtest_C1 = model.predict(testX, verbose = 1)
print(testingtest_C1[0], testingtest_C1.shape)
trainScore = math.sqrt(mean_squared_error(trainY[:,1,:], testingtrain_C1[:,1,:]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest_C1[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
trainMAE = np.mean(mae(trainY[:,1,:], testingtrain_C1[:,1,:]))
print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], testingtest_C1[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,47,:])
plt.show()
plt.imshow(testingtest_C1[:48,47,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,1,:1], marker='.', label="actual")
plt.plot(aa, testingtest_C1[:,1,:1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
####################
X_SU_C2 = X_SU_C2.drop(columns = 'cluster')
X_SU_C2 = X_SU_C2.transpose()
X_SU_C2.head()
X_SU_C2 = X_SU_C2.values
cap = np.percentile(X_SU_C2, 97)
X_SU_C2[X_SU_C2 > cap] = cap
training_size=int(X_SU_C2.shape[0]*0.80)
test_size=(X_SU_C2.shape[0])-training_size
train,test=X_SU_C2[0:training_size],X_SU_C2[training_size:(X_SU_C2.shape[0])]
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape, '\n',
testX.shape, testY.shape)
###Building a sequential network:
Model_2 = models.Sequential()
Model_2.add(layers.Dense(1500, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model_2.add(Dropout(0.5))
Model_2.add(BatchNormalization())
Model_2.add(layers.Dense(50, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model_2.add(Dropout(0.5))
Model_2.add(BatchNormalization())
Model_2.add((Dense(trainX.shape[2])))
Model_2.compile(optimizer= optimizers.Adam(lr=0.001), loss='mse', metrics=['mae'])
Model_2.summary()
model_train = Model_2.fit(trainX,trainY, epochs=50, validation_split = 0.05, batch_size = 64)
Seq_train = Model_2.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model_2.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
trainScore = math.sqrt(mean_squared_error(trainY[:,1,:], Seq_train[:,1,:]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
trainMAE = np.mean(mae(trainY[:,1,:], Seq_train[:,1,:]))
print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,47,:])
plt.show()
plt.imshow(Seq_test[:48,47,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,47,1], marker='.', label="actual")
plt.plot(aa, Seq_test[:,47,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
model = Sequential()
model.add(LSTM(70, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
#model.add(LSTM(100, activation='relu'))
model.add(Dense(trainX.shape[2]))
#model.add(Dropout(.01))
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
model.summary()
# fit model
history_C2 = model.fit(trainX,trainY, epochs=30, validation_split = 0.05, batch_size=32, callbacks=[lr_decay])
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_C2.history['loss'], label='train')
plt.plot(history_C2.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
testingtrain_C2 = model.predict(trainX, verbose = 1)
print(testingtrain_C2[0], testingtrain_C2.shape)
testingtest_C2 = model.predict(testX, verbose = 1)
print(testingtest_C2[0], testingtest_C2.shape)
trainScore = math.sqrt(mean_squared_error(trainY[:,1,:], testingtrain_C2[:,1,:]))
print('Test Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest_C2[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
trainMAE = np.mean(mae(trainY[:,1,:], testingtrain_C2[:,1,:]))
print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], testingtest_C2[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,1,:])
plt.show()
plt.imshow(testingtest_C2[:48,1,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,1,:1], marker='.', label="actual")
plt.plot(aa, testingtest_C2[:,1,:1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
########cluster 3
X_SU_C3 = X_SU_C3.drop(columns = 'cluster')
X_SU_C3 = X_SU_C3.transpose()
X_SU_C3.head()
X_SU_C3 = X_SU_C3.values
cap = np.percentile(X_SU_C2, 97)
X_SU_C2[X_SU_C2 > cap] = cap
training_size=int(X_SU_C3.shape[0]*0.80)
test_size=(X_SU_C3.shape[0])-training_size
train,test=X_SU_C3[0:training_size],X_SU_C3[training_size:(X_SU_C3.shape[0])]
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape, '\n',
testX.shape, testY.shape)
###Building a sequential network:
Model_3 = models.Sequential()
Model_3.add(layers.Dense(400, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model_3.add(Dropout(0.2))
Model_3.add(layers.Dense(200, activation='relu'))
Model_3.add(Dropout(0.2))
Model_3.add((Dense(trainX.shape[2])))
Model_3.compile(optimizer= optimizers.Adam(lr=0.001), loss='mse', metrics=['mae'])
Model_3.summary()
model_train = Model_3.fit(trainX,trainY, epochs=50, validation_split = 0.05, batch_size=64)
Seq_train = Model_3.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model_3.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
#trainScore = math.sqrt(mean_squared_error(trainY_RMSE, testingtrain_C1))
#print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:48,1,1], Seq_test[:48,1,1]))
print('Test Score: %.2f RMSE' % (testScore))
#trainMAE = np.mean(mae(trainY[:48,1,1], testingtrain_C2[:48,1,1]))
#print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:48,1,1], Seq_test[:48,1,1]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,47,:])
plt.show()
plt.imshow(Seq_test[:48,47,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,47,1], marker='.', label="actual")
plt.plot(aa, Seq_test[:,47,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
model = Sequential()
model.add(LSTM(200, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
#model.add(Dense(30))
model.add(Dense(trainX.shape[2]))
#model.add(Dropout(.01))
#sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9), 'optimizers.Adam(lr=0.01)'
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
model.summary()
# fit model
history_C3 = model.fit(trainX,trainY, epochs=50, validation_split = 0.05, batch_size=64, callbacks=[lr_decay])
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_C3.history['loss'], label='train')
plt.plot(history_C3.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
testingtrain_C3 = model.predict(trainX, verbose = 1)
print(testingtrain_C3[0], testingtrain_C3.shape)
testingtest_C3 = model.predict(testX, verbose = 1)
print(testingtest_C3[0], testingtest_C3.shape)
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest_C3[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
testMAE = np.mean(mae(testY[:,1,:], testingtest_C3[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,1,:])
plt.show()
plt.imshow(testingtest_C3[:48,1,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,1,:1], marker='.', label="actual")
plt.plot(aa, testingtest_C3[:,1,:1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
########cluster 4
X_SU_C4 = X_SU_C4.drop(columns = 'cluster')
X_SU_C4 = X_SU_C4.transpose()
X_SU_C4.head()
X_SU_C4 = X_SU_C4.values
cap = np.percentile(X_SU_C4, 97)
X_SU_C4[X_SU_C4 > cap] = cap
training_size=int(X_SU_C4.shape[0]*0.80)
test_size=(X_SU_C4.shape[0])-training_size
train,test=X_SU_C4[0:training_size],X_SU_C4[training_size:(X_SU_C4.shape[0])]
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape, '\n',
testX.shape, testY.shape)
###Building a sequential network:
Model_4 = models.Sequential()
Model_4.add(layers.Dense(100, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model_4.add(Dropout(0.2))
Model_4.add(layers.Dense(50, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model_4.add(Dropout(0.2))
Model_4.add((Dense(trainX.shape[2])))
Model_4.compile(optimizer= optimizers.Adam(lr=0.001), loss='mse', metrics=['mae'])
Model_4.summary()
model_train = Model_4.fit(trainX,trainY, epochs=20, validation_split = 0.05, batch_size=64)
Seq_train = Model_4.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model_4.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
#trainScore = math.sqrt(mean_squared_error(trainY_RMSE, testingtrain_C1))
#print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
#trainMAE = np.mean(mae(trainY[:48,1,1], testingtrain_C2[:48,1,1]))
#print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,47,:])
plt.show()
plt.imshow(Seq_test[:48,47,:])
plt.show()
aa=[x for x in range(300)]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:300,1,1], marker='.', label="actual")
plt.plot(aa, Seq_test[:300,1,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
model = Sequential()
model.add(LSTM(100, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
model.add(Dense(trainX.shape[2]))
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
model.summary()
# fit model
history_C4 = model.fit(trainX,trainY, epochs=20, callbacks=[lr_decay], validation_split=0.05, batch_size= 64)
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_C4.history['loss'], label='train')
plt.plot(history_C4.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
testingtrain_C4 = model.predict(trainX, verbose = 1)
print(testingtrain_C4[0], testingtrain_C4.shape)
testingtest_C4 = model.predict(testX, verbose = 1)
print(testingtest_C4[0], testingtest_C4.shape)
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest_C4[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
testMAE = np.mean(mae(testY[:,1,:], testingtest_C4[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,1,:])
plt.show()
plt.imshow(testingtest_C4[:48,1,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,1,1], marker='.', label="actual")
plt.plot(aa, testingtest_C4[:,1,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
km_4_SP = KMeans(4).fit(X_SP)
pd.Series.value_counts(km_4_SP.labels_)
X_SP['cluster'] = km_4_SP.labels_
X_SP_C1 = X_SP[X_SP.cluster == 0]
X_SP_C2 = X_SP[X_SP.cluster == 1]
X_SP_C3 = X_SP[X_SP.cluster == 2]
X_SP_C4 = X_SP[X_SP.cluster == 3]
#X_A_C5 = X_A[X_A.cluster == 4]
#X_A_C6 = X_A[X_A.cluster == 5]
X_SP_C1 = X_SP_C1.drop(columns = 'cluster')
X_SP_C1 = X_SP_C1.transpose()
X_SP_C1.head()
X_SP_C1 = X_SP_C1.values
cap = np.percentile(X_SP_C1, 97)
X_SP_C1[X_SP_C1 > cap] = cap
training_size=int(X_SP_C1.shape[0]*0.80)
test_size=(X_SP_C1.shape[0])-training_size
train,test=X_SP_C1[0:training_size],X_SP_C1[training_size:(X_SP_C1.shape[0])]
def get_batches(data, input_interval, target_interval, output_step_offset):
batched_data_x = []
batched_data_y = []
for i in range(input_interval, (len(data) - target_interval - output_step_offset)):
batched_data_x.append(data[i-input_interval:i])
batched_data_y.append(data[i+output_step_offset:i+target_interval+output_step_offset])
batched_data_x, batched_data_y = np.array(batched_data_x), np.array(batched_data_y)
return batched_data_x, batched_data_y
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape)
print(testX.shape, testY.shape)
###Building a sequential network:
Model_1 = models.Sequential()
Model_1.add(layers.Dense(400, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model_1.add(Dropout(0.2))
Model_1.add(BatchNormalization())
Model_1.add(layers.Dense(200, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model_1.add(Dropout(0.2))
Model_1.add(BatchNormalization())
Model_1.add((Dense(trainX.shape[2])))
Model_1.compile(optimizer= optimizers.Adam(lr=0.001), loss='mse', metrics=['mae'])
Model_1.summary()
model_train = Model_1.fit(trainX,trainY, epochs=20, validation_split = 0.10, batch_size=64)
Seq_train = Model_1.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model_1.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
def rmse(actual, pred):
return np.sqrt(((pred - actual) ** 2).mean())
def mae(actual, pred):
return np.mean(np.abs(actual - pred))
testMAE = np.mean(mae(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
plt.imshow(testY[:48,47,:])
plt.show()
plt.imshow(Seq_test[:48,47,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,47,1], marker='.', label="actual")
plt.plot(aa, Seq_test[:,47,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
lr_decay = callbacks.LearningRateScheduler(schedule=lambda epoch: 0.001 * (0.80 ** epoch))
model = Sequential()
model.add(LSTM(100, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
#model.add(Dense(84))
#model.add(Dropout(.5))
#model.add(LSTM(50, activation='relu', return_sequences = True))
#model.add(Dropout(.01))
model.add(Dense(trainX.shape[2]))
#sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9), 'optimizers.Adam(lr=0.01)'
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
model.summary()
# fit model
history_SP_C1 = model.fit(trainX,trainY, epochs=30, batch_size=64, callbacks=[lr_decay], validation_split = 0.10)
#, callbacks=[lr_decay]
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_SP_C1.history['loss'], label='train')
#plt.plot(history_SP_C1.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
testingtrain_C1 = model.predict(trainX, verbose = 1)
print(testingtrain_C1[0], testingtrain_C1.shape)
testingtest_C1 = model.predict(testX, verbose = 1)
print(testingtest_C1[0], testingtest_C1.shape)
trainScore = math.sqrt(mean_squared_error(trainY[:,1,:], testingtrain_C1[:,1,:]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest_C1[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
trainMAE = np.mean(mae(trainY[:,1,:], testingtrain_C1[:,1,:]))
print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], testingtest_C1[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:47,47,:])
plt.show()
plt.imshow(testingtest_C1[:47,47,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,1,30], marker='.', label="actual")
plt.plot(aa, testingtest_C1[:,1,30], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
X_SP_C2 = X_SP_C2.drop(columns = 'cluster')
X_SP_C2 = X_SP_C2.transpose()
X_SP_C2.head()
X_SP_C2 = X_SP_C2.values
cap = np.percentile(X_SP_C2, 97)
X_SP_C2[X_SP_C2 > cap] = cap
training_size=int(X_SP_C2.shape[0]*0.80)
test_size=(X_SP_C2.shape[0])-training_size
train,test=X_SP_C2[0:training_size],X_SP_C2[training_size:(X_SP_C2.shape[0])]
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape, '\n',
testX.shape, testY.shape)
###Building a sequential network:
Model_2 = models.Sequential()
Model_2.add(layers.Dense(600, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model_2.add(Dropout(0.2))
Model_2.add(BatchNormalization())
Model_2.add(layers.Dense(300, activation='relu'))
Model_2.add(Dropout(0.2))
Model_2.add(BatchNormalization())
Model_2.add((Dense(trainX.shape[2])))
Model_2.compile(optimizer= optimizers.Adam(lr=0.001), loss='mse', metrics=['mae'])
Model_2.summary()
model_train = Model_2.fit(trainX,trainY, epochs=20, validation_split = 0.150, batch_size=64)
Seq_train = Model_2.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model_2.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
#trainScore = math.sqrt(mean_squared_error(trainY_RMSE, testingtrain_C1))
#print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
#trainMAE = np.mean(mae(trainY[:48,1,1], testingtrain_C2[:48,1,1]))
#print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,47,:])
plt.show()
plt.imshow(Seq_test[:48,47,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,47,1], marker='.', label="actual")
plt.plot(aa, Seq_test[:,47,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
model = Sequential()
model.add(LSTM(200, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
#model.add(Dense(138))
model.add(Dense(trainX.shape[2]))
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
model.summary()
# fit model
history_C2 = model.fit(trainX,trainY, epochs=20, validation_split = 0.10, callbacks=[lr_decay], batch_size=64)
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_C2.history['loss'], label='train')
plt.plot(history_C2.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
testingtrain_C2 = model.predict(trainX, verbose = 1)
print(testingtrain_C2[0], testingtrain_C2.shape)
testingtest_C2 = model.predict(testX, verbose = 1)
print(testingtest_C2[0], testingtest_C2.shape)
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest_C2[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
#trainMAE = np.mean(mae(trainY_RMSE, testingtrain_C2))
#print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], testingtest_C2[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,1,:])
plt.show()
plt.imshow(testingtest_C2[:48,1,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,1,1], marker='.', label="actual")
plt.plot(aa, testingtest_C2[:,1,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
########cluster 3
X_SP_C3 = X_SP_C3.drop(columns = 'cluster')
X_SP_C3 = X_SP_C3.transpose()
X_SP_C3.head()
X_SP_C3 = X_SP_C3.values
cap = np.percentile(X_SP_C2, 97)
X_SP_C2[X_SP_C2 > cap] = cap
training_size=int(X_SP_C3.shape[0]*0.80)
test_size=(X_SP_C3.shape[0])-training_size
train,test=X_SP_C3[0:training_size],X_SP_C3[training_size:(X_SP_C3.shape[0])]
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape, '\n',
testX.shape, testY.shape)
###Building a sequential network:
Model_3 = models.Sequential()
Model_3.add(layers.Dense(200, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model_3.add(Dropout(0.2))
Model_3.add(BatchNormalization())
Model_3.add(layers.Dense(100, activation='relu'))
Model_3.add(Dropout(0.2))
Model_3.add(BatchNormalization())
Model_3.add((Dense(trainX.shape[2])))
Model_3.compile(optimizer= optimizers.Adam(lr=0.001), loss='mse', metrics=['mae'])
Model_3.summary()
model_train = Model_3.fit(trainX,trainY, epochs=20, validation_split = 0.10, batch_size=64)
Seq_train = Model_3.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model_3.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
#trainScore = math.sqrt(mean_squared_error(trainY_RMSE, testingtrain_C1))
#print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
#trainMAE = np.mean(mae(trainY[:48,1,1], testingtrain_C2[:48,1,1]))
#print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,47,:])
plt.show()
plt.imshow(Seq_test[:48,47,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,47,1], marker='.', label="actual")
plt.plot(aa, Seq_test[:,47,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
model = Sequential()
model.add(LSTM(100, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
model.add(Dense(trainX.shape[2]))
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
model.summary()
# fit model
history_C3 = model.fit(trainX,trainY, epochs=20, batch_size=64, validation_split = 0.10, callbacks=[lr_decay])
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_C3.history['loss'], label='train')
plt.plot(history_C3.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
testingtrain_C3 = model.predict(trainX, verbose = 1)
print(testingtrain_C3[0], testingtrain_C3.shape)
testingtest_C3 = model.predict(testX, verbose = 1)
print(testingtest_C3[0], testingtest_C3.shape)
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest_C3[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
testMAE = np.mean(mae(testY[:,1,:], testingtest_C3[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,1,:])
plt.show()
plt.imshow(testingtest_C3[:48,1,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,1,1], marker='.', label="actual")
plt.plot(aa, testingtest_C3[:,1,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
########cluster 4
X_SP_C4 = X_SP[X_SP.cluster == 3]
X_SP_C4 = X_SP_C4.drop(columns = 'cluster')
X_SP_C4 = X_SP_C4.transpose()
X_SP_C4.head()
X_SP_C4 = X_SP_C4.values
cap = np.percentile(X_SP_C4, 97)
X_SP_C4[X_SP_C4 > cap] = cap
X_SP_C4.max()
training_size=int(X_SP_C4.shape[0]*0.80)
test_size=(X_SP_C4.shape[0])-training_size
train,test=X_SP_C4[0:training_size],X_SP_C4[training_size:(X_SP_C4.shape[0])]
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape, '\n',
testX.shape, testY.shape)
###Building a sequential network:
Model_4 = models.Sequential()
Model_4.add(layers.Dense(100, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model_4.add(Dropout(0.2))
Model_4.add(BatchNormalization())
Model_4.add(layers.Dense(50, activation='relu'))
Model_4.add(Dropout(0.2))
Model_4.add(BatchNormalization())
Model_4.add((Dense(trainX.shape[2])))
Model_4.compile(optimizer= optimizers.Adam(lr=0.001), loss='mse', metrics=['mae'])
Model_4.summary()
model_train = Model_4.fit(trainX,trainY, epochs=30, batch_size=32, validation_split = 0.10)
Seq_train = Model_4.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model_4.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
#trainScore = math.sqrt(mean_squared_error(trainY_RMSE, testingtrain_C1))
#print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
#trainMAE = np.mean(mae(trainY[:48,1,1], testingtrain_C2[:48,1,1]))
#print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,47,:])
plt.show()
plt.imshow(Seq_test[:48,47,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,47,1], marker='.', label="actual")
plt.plot(aa, Seq_test[:,47,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
model = Sequential()
model.add(LSTM(50, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
model.add(Dropout(.2))
model.add(Dense(50))
model.add(Dropout(.2))
model.add(Dense(trainX.shape[2]))
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
model.summary()
# fit model
history_C4 = model.fit(trainX,trainY, epochs=20, validation_split = 0.10, batch_size=32, callbacks=[lr_decay])
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_C4.history['loss'], label='train')
plt.plot(history_C4.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
testingtrain_C4 = model.predict(trainX, verbose = 1)
print(testingtrain_C4[0], testingtrain_C4.shape)
testingtest_C4 = model.predict(testX, verbose = 1)
print(testingtest_C4[0], testingtest_C4.shape)
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest_C4[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
testMAE = np.mean(mae(testY[:,1,:], testingtest_C4[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,1,:])
plt.show()
plt.imshow(testingtest_C4[:48,1,:])
plt.show()
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,1,1], marker='.', label="actual")
plt.plot(aa, testingtest_C4[:,1,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
df_W = df_W.groupby(['Datetime']).mean()
df_W.head()
################
#df_W = df_W.transpose()
df_W.shape
df_W = df_W.values
#cap = np.percentile(X_A_C1, 97)
#X_A_C1[X_A_C1 > cap] = cap
training_size=int(df_W.shape[0]*0.80)
test_size=(df_W.shape[0])-training_size
train,test=df_W[0:training_size],df_W[training_size:(df_W.shape[0])]
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape)
print(testX.shape, testY.shape)
###Building a sequential network:
Model = models.Sequential()
Model.add(layers.Dense(900, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model.add(Dropout(0.5))
Model.add(BatchNormalization())
Model.add(layers.Dense(600, activation='relu'))
Model.add(Dropout(0.5))
Model.add(BatchNormalization())
Model.add((Dense(trainX.shape[2])))
Model.compile(optimizer= optimizers.Adam(lr=0.001), loss='mse', metrics=['mae'])
Model.summary()
model_train = Model.fit(trainX,trainY, epochs=30, validation_split = 0.10, batch_size=64)
Seq_train = Model.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
testMAE = np.mean(mae(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
plt.imshow(testY[:48,47,:])
plt.show()
plt.imshow(Seq_test[:48,47,:])
plt.show()
aa=[x for x in range(300)]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:300,1,5], marker='.', label="actual")
plt.plot(aa, Seq_test[:300,1,5], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
model = Sequential()
model.add(LSTM(300, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
model.add(Dense(trainX.shape[2]))
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = ['mae'], loss='mse')
model.summary()
# fit model
history_W = model.fit(trainX,trainY, epochs=20, batch_size=64, validation_split = 0.10, callbacks=[lr_decay])
#, callbacks=[lr_decay]
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_W.history['loss'], label='train')
plt.plot(history_W.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
testingtrain = model.predict(trainX, verbose = 1)
print(testingtrain[0], testingtrain.shape)
testingtest = model.predict(testX, verbose = 1)
print(testingtest[0], testingtest.shape)
trainScore = math.sqrt(mean_squared_error(trainY[:,1,:], testingtrain[:,1,:]))
print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
trainMAE = np.mean(mae(trainY[:,1,:], testingtrain[:,1,:]))
print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], testingtest[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
plt.imshow(testY[:48,1,:])
plt.show()
plt.imshow(testingtest[:48,1,:])
plt.show()
aa=[x for x in range(300)]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:300,1,1], marker='.', label="actual")
plt.plot(aa, testingtest[:300,1,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
df_A = df_A.groupby(['Datetime']).mean()
df_A.head()
df_A = df_A.values
#cap = np.percentile(X_A_C1, 97)
#X_A_C1[X_A_C1 > cap] = cap
training_size=int(df_A.shape[0]*0.80)
test_size=(df_A.shape[0])-training_size
train,test= df_A[0:training_size],df_A[training_size:(df_A.shape[0])]
print(train.shape, test.shape)
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape, '\n',
testX.shape, testY.shape)
###Building a sequential network:
Model = models.Sequential()
Model.add(layers.Dense(500, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model.add(Dropout(0.2))
Model.add(BatchNormalization())
Model.add(layers.Dense(300, activation='relu'))
Model.add(Dropout(0.2))
Model.add(BatchNormalization())
Model.add((Dense(trainX.shape[2])))
Model.compile(optimizer= optimizers.Adam(lr=0.001), loss='mse', metrics=['mae'])
Model.summary()
model_train = Model.fit(trainX,trainY, epochs=20, validation_split = 0.10, batch_size = 64)
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(model_train.history['loss'], label='train')
plt.plot(model_train.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
Seq_train = Model.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
plt.imshow(testY[:48,1,:])
plt.show()
plt.imshow(Seq_test[:48,1,:])
plt.show()
#trainScore = math.sqrt(mean_squared_error(trainY_RMSE, testingtrain_C1))
#print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
testMAE = np.mean(mae(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
aa=[x for x in range(300)]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:300,1,1])
plt.plot(aa, Seq_test[:300,1,1],'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
model = Sequential()
model.add(LSTM(200, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
#model.add(LSTM(100, activation='relu'))
model.add(Dense(trainX.shape[2]))
#sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9), 'optimizers.Adam(lr=0.01)'
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
model.summary()
##### fit model
history_A = model.fit(trainX, trainY, epochs=20, validation_split = 0.10, batch_size = 64, callbacks=[lr_decay])
#validation_data = (valX, valY)
testingtrain = model.predict(trainX, verbose = 1)
print(testingtrain[0], testingtrain.shape)
testingtest = model.predict(testX, verbose = 1)
print(testingtest[0], testingtest.shape)
plt.imshow(testY[:48,1,:])
plt.show()
plt.imshow(testingtest[:48,1,:])
plt.show()
#trainScore = math.sqrt(mean_squared_error(trainY_RMSE, testingtrain_C1))
#print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
#trainMAE = np.mean(mae(trainY[:48,1,1], testingtrain_C2[:48,1,1]))
#print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], testingtest[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
aa=[x for x in range(300)]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:300,1,1], marker='.', label="actual")
plt.plot(aa, testingtest[:300,1,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
df_SU.head()
df_SU = df_SU.values
#cap = np.percentile(X_A_C1, 97)
#X_A_C1[X_A_C1 > cap] = cap
#print(X_A_C1.shape)
training_size=int(df_SU.shape[0]*0.80)
test_size=(df_SU.shape[0])-training_size
train,test=df_SU[0:training_size],df_SU[training_size:(df_SU.shape[0])]
print(train.shape, test.shape)
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape, '\n',
testX.shape, testY.shape)
###Building a sequential network:
Model = models.Sequential()
Model.add(layers.Dense(500, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model.add(Dropout(0.2))
Model.add(BatchNormalization())
Model.add(layers.Dense(300, activation='relu'))
Model.add(Dropout(0.2))
Model.add(BatchNormalization())
Model.add((Dense(trainX.shape[2])))
Model.compile(optimizer= optimizers.Adam(lr=0.001), loss='mse', metrics=['mae'])
Model.summary()
model_train = Model.fit(trainX,trainY, epochs=20, validation_split = 0.10, batch_size = 64)
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(model_train.history['loss'], label='train')
plt.plot(model_train.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
Seq_train = Model.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
plt.imshow(testY[:48,1,:])
plt.show()
plt.imshow(Seq_test[:48,1,:])
plt.show()
#trainScore = math.sqrt(mean_squared_error(trainY_RMSE, testingtrain_C1))
#print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
testMAE = np.mean(mae(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
aa=[x for x in range(300)]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:300,1,1])
plt.plot(aa, Seq_test[:300,1,1],'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
model = Sequential()
model.add(LSTM(200, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
#model.add(LSTM(100, activation='relu'))
model.add(Dense(trainX.shape[2]))
#sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9), 'optimizers.Adam(lr=0.01)'
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
model.summary()
##### fit model
history_SU = model.fit(trainX, trainY, epochs=20, validation_split = 0.10, batch_size = 64, callbacks=[lr_decay])
#validation_data = (valX, valY)
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_SU.history['loss'], label='train')
plt.plot(history_SU.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
testingtrain_SU = model.predict(trainX, verbose = 1)
print(testingtrain_SU[0], testingtrain_SU.shape)
testingtest_SU = model.predict(testX, verbose = 1)
print(testingtest_SU[0], testingtest_SU.shape)
#trainScore = math.sqrt(mean_squared_error(trainY_RMSE, testingtrain_C1))
#print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest_SU[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
#trainMAE = np.mean(mae(trainY[:48,1,1], testingtrain_C2[:48,1,1]))
#print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], testingtest_SU[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
aa=[x for x in range(300)]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:300,1,1], marker='.', label="actual")
plt.plot(aa, testingtest_SU[:300,1,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
df_SP.head()
df_SP = df_SP.values
#cap = np.percentile(X_A_C2, 97)
#X_A_C2[X_A_C2 > cap] = cap
training_size=int(df_SP.shape[0]*0.80)
test_size=(df_SP.shape[0])-training_size
train,test=df_SP[0:training_size],df_SP[training_size:(df_SP.shape[0])]
trainX, trainY = get_batches(train, 48, 48, 48)
testX, testY = get_batches(test, 48, 48, 48)
print(trainX.shape, trainY.shape, '\n',
testX.shape, testY.shape)
###Building a sequential network:
Model = models.Sequential()
Model.add(layers.Dense(300, activation='relu', input_shape=(trainX.shape[1],trainX.shape[2])))
Model.add(Dropout(.2))
Model.add(BatchNormalization())
Model.add(layers.Dense(100, activation='relu'))
Model.add(Dropout(.2))
Model.add(BatchNormalization())
Model.add((Dense(trainX.shape[2])))
Model.compile(optimizer= 'adam', loss='mse', metrics=['mae'])
Model.summary()
model_train = Model.fit(trainX,trainY, epochs=20, validation_split = 0.10, batch_size = 64)
Seq_train = Model.predict(trainX, verbose = 1)
print(Seq_train[0], Seq_train.shape)
Seq_test = Model.predict(testX, verbose = 1)
print(Seq_test[0], Seq_test.shape)
#trainScore = math.sqrt(mean_squared_error(trainY_RMSE, testingtrain_C1))
#print('Train Score: %.2f RMSE' % (trainScore))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
#trainMAE = np.mean(mae(trainY[:48,1,1], testingtrain_C2[:48,1,1]))
#print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], Seq_test[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
aa=[x for x in range(200)]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:200,1,1], marker='.', label="actual")
plt.plot(aa, Seq_test[:200,1,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
model = Sequential()
model.add(LSTM(200, activation='relu', input_shape =(trainX.shape[1],trainX.shape[2]), return_sequences = True))
#model.add(Dense(507))
model.add(Dense(trainX.shape[2]))
#model.add(BatchNormalization())
#model.add(Dropout(.01))
#sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9), 'optimizers.Adam(lr=0.01)'
model.compile(optimizer = optimizers.Adam(lr=0.001), metrics = 'mae', loss='mse')
model.summary()
# fit model
history_SP = model.fit(trainX,trainY, epochs=20, validation_split = 0.10, batch_size = 32, callbacks=[lr_decay])
fig = plt.figure(figsize=(5,3), dpi=75) #set figure size
plt.plot(history_SP.history['loss'], label='train')
plt.plot(history_SP.history['val_loss'], label='val')
plt.ylabel('Pérdida')
plt.xlabel('Epoch')
plt.legend()
plt.show()
testingtrain_SP = model.predict(trainX, verbose = 1)
print(testingtrain_SP[0], testingtrain_SP.shape)
testingtest_SP = model.predict(testX, verbose = 1)
print(testingtest_SP[0], testingtest_SP.shape)
#trainScore = math.sqrt(mean_squared_error(trainY_RMSE, testingtrain_C2))
#print('Train RMSE Score: %.2f' % (trainScore))
#testScore = math.sqrt(mean_squared_error(testY_RMSE, testingtest_C2))
#print('Test RMSE Score: %.2f' % (testScore))
testScore = math.sqrt(mean_squared_error(testY[:,1,:], testingtest_SP[:,1,:]))
print('Test Score: %.2f RMSE' % (testScore))
#trainMAE = np.mean(mae(trainY_RMSE, testingtrain_C2))
#print('Train Score: %.2f MAE' % (trainMAE))
testMAE = np.mean(mae(testY[:,1,:], testingtest_SP[:,1,:]))
print('Test Score: %.2f MAE' % (testMAE))
aa=[x for x in range(testY.shape[0])]
plt.figure(figsize=(20,5))
plt.plot(aa, testY[:,1,1], marker='.', label="actual")
plt.plot(aa, testingtest_SP[:,1,1], 'r', label="prediction")
plt.ylabel('Energy', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()